Results on the Average State and Transition Complexity of Finite Automata Accepting Finite Languages (Extended Abstract)

The study of descriptional complexity issues for finite automata dates back to the mid 1950’s. One of the earliest results is that deterministic and nondeterministic finite automata are computationally equivalent, and that nondeterministic finite automata can offer exponential state savings compared to deterministic ones, see [11]—by the powerset construction one increases the number of states from n to 2n, which is known to be a tight bound. Motivated by several applications and implementations of finite automata in software engineering, programming languages and other practical areas in computer science, the descriptional complexity of finite automata problems has gained new interest during the last decade. Tight upper bounds for the deterministic and nondeterministic state complexity of many operations on regular languages are known [8, 11, 12]. In many applications the regular languages are actually finite as, e.g., in natural language processing or constraint satisfaction problems in artificial intelligence. This prompted quite some research activity on finite languages—see [11] for an overview. Obviously, the length of the longest word in a finite language is a lower bound on the number of states of a finite automaton accepting a finite language. In fact it can be even exponential in the length of the longest word in the finite language as shown in [2, 5]. To be more precise, there is a finite language L over a binary alphabet whose longest word is of length n such that the minimal deterministic finite automaton accepting L needs Θ( n n ) states. For the state savings for changing from a deterministic finite automaton to a nondeterministic finite automaton the bounds for automata accepting finite languages is slightly weaker than in the general case. In [10] it was shown that one can transform every nondeterministic finite automaton accepting a finite language into an equivalent deterministic finite automaton increasing the number of states from n to Θ( √ 2), and this bound was shown to be sharp. More results on the state complexity of operations on finite languages can be found in [3, 8]. However, most of the work on descriptional complexity of regular languages yields worst-case results. To our knowledge, very few attempts have been made in order to understand certain aspects of the average behaviour of regular languages [1, 4, 6, 9]. Average-case complexity turns out to be much harder to determine than worst-case complexity, as it is currently unknown how many non-isomorphic automata of n states there are over a binary alphabet. For a recent survey on the problem of enumerating finite automata we refer to [7]. However, for finite automata with a singleton letter input alphabet the enumeration problem was solved in [9], 2 H. Gruber and M. Holzer where also the average-case state complexity of operations on unary languages was studied. In this paper we concentrate on the average-case descriptional complexity of deterministic and nondeterministic finite automata accepting finite languages. By choosing a finite language L with given maximal word length uniformly at random, one can treat the size of the minimal deterministic or nondeterministic finite automaton accepting L as a random variable. Observe that our setup is different to that used in [9]. There deterministic finite automata are chosen at random among all n-state deterministic finite automata, whereas our setup is centered at languages. Due to this difference in the model, the results on finite languages cannot be directly compared to each other. At first glance we show that almost all deterministic finite automata accepting finite languages over a binary input alphabet with word length at most n have state complexity Θ( n n ), which is asymptotically like the worst-case. Then we introduce a stochastic process to generate finite languages, which is shown to be equivalent to the above mentioned setup choosing a finite language uniformly at random. This stochastic language generation process allows us to investigate operations on finite languages from the average-case point of view. It turns out that the expected value of the state complexity of a deterministic finite automaton accepting the union or intersection of two finite languages is larger than 4 5 · 2n n on the average, as n tends to infinity. Similar bounds can be derived for the iteration of Boolean operations. Moreover, the average-case complexity of operations on finite unary languages is determined exactly. Finally, nondeterministic finite automata are considered. It turns out that the nondeterministic state complexity is in Θ( √ 2) on the average, which is superior to the deterministic case with respect to the number of states. However, interestingly we show that the number of transitions needed is again Θ( n n ) in most cases. Hence, the overall size, i.e., the length of a description of a finite state machine, is from the average-case complexity point of view the same for both deterministic and nondeterministic finite automata. Finally, we note that results similar to those for the binary case can be derived for larger alphabet sizes along the way outlined here.